/*!

 * \file bigint.h

 * \brief Header du projet

 * \author Nous 5

 * \version 1

 */
 
#include <vector>

#include <string>

/*! \class BigInt
* \brief classe representant un grand entier
*
*  La classe gere les grands entiers positifs et négatifs
*/


class BigInt

{

  private:

    std::vector<int> tab;

    bool signe ; // true = positif



    public:
    
		/*!
		* \brief Constructeur vide, initialise juste le signe sur true
		*
		*/

        BigInt(); 
        
        
		/*!
		* \brief Constructeur, initialise les attributs
		* \param Un string rentré dans le main par un monsieur (ou une madame(ou une demoiselle))
		*
		*/		

        BigInt(std::string expr);
        
        
		/*!
		* \brief Constructeur de recopie
		* \param Un Bigint à recopier
		*
		*/		

        BigInt(const BigInt &a);
        
        
		/*!
		* \brief Opérateur de comparaison ==
		* \param BigInt à comparer à un autre passé implicitement en argument
		* \return un booléen, true si c'est ==
		*/ 		         

        bool operator==(const BigInt& a);
        
        
 		/*!
		* \brief Opérateur de comparaison !=
		* \param BigInt à comparer à un autre passé implicitement en argument
		* \return un booléen, l'inverse de ==
		*/  		     

        bool operator!=(const BigInt& a);
        
        
 		/*!
		* \brief Opérateur de comparaison >, on compare la taille, puis le signe, puis les chiffres un à un
		* \param BigInt à comparer à un autre passé implicitement en argument
		* \return un booléen, true si c'est >
		*/ 		      

        bool operator>(const BigInt& a);
        
        
        
 		/*!
		* \brief Opérateur de comparaison <
		* \param BigInt à comparer à un autre passé implicitement en argument
		* \return un booléen, l'inverse de >=
		*/ 	      

        bool operator<(const BigInt& a);
        
        
		/*!
		* \brief Opérateur de comparaison <=
		* \param BigInt à comparer à un autre passé implicitement en argument
		* \return un booléen, true si < ou ==
		*/  	      

        bool operator<=(const BigInt& a);
        
        
 		/*!
		* \brief Opérateur de comparaison >=
		* \param BigInt à comparer à un autre passé implicitement en argument
		* \return un booléen, l'inverse de <
		*/ 		      

        bool operator>=(const BigInt& a);
        
        
		/*!
		* \brief Opération +
		* \param BigInt à additionner à un autre passé implicitement en argument
		* \return un BigInt, somme des 2 en arguments
		*/ 		       

        BigInt operator+(const BigInt& a);
        
        
 		/*!
		* \brief Opération +=
		* \param BigInt à additionner à un autre passé implicitement en argument
		* \return l'adresse d'un BigInt, somme des 2 en arguments
		*/  		     

        BigInt& operator+=(const BigInt& a);
        
        
  		/*!
		* \brief Opération ++
		* \return un BigInt incrémenté de 1
		*/  		    

        BigInt operator++();
        
        
 		/*!
		* \brief Opération -=
		* \param BigInt à soustraire à un autre passé implicitement en argument
		* \return l'adresse d'un BigInt, différence des 2 en arguments
		*/  	     

        BigInt& operator-=(const BigInt& a);
        
        
 		/*!
		* \brief Opération -
		* \return BigInt opposé à celui passé en argument
		*/ 		      

        BigInt operator-() const;
        
        
 		/*!
		* \brief Opération -
		* \param BigInt à soustraire à un autre passé implicitement en argument
		* \return un BigInt, différence des 2 en arguments
		*/   		    

        BigInt operator-(const BigInt& a);
        
        
  		/*!
		* \brief Opération --
		* \return un BigInt décrémenté de 1
		*/      

        BigInt operator--();
        
        
  		/*!
		* \brief Opération *=
		* \param BigInt à multiplier à un autre passé implicitement en argument
		* \return l'adresse d'un BigInt, produit des 2 en arguments
		*/      	

        BigInt& operator*=(const BigInt& a);
        
        
 		/*!
		* \brief Opération *
		* \param BigInt à multiplier à un autre passé implicitement en argument
		* \return un BigInt, produit des 2 en arguments
		*/  	      

        BigInt operator*(const BigInt& a); 
        
        
 		/*!
		* \brief Fonction ami de BigInt (pour utiliser ses variables
		* \param Un BigInt 
		* \return La valeur absolue du BigInt passé en argument 
		*/       	

        friend BigInt v_pos(const BigInt& a);
        
        
        
 		/*!
		* \brief Affiche un BigInt
		*
		*/       	

        void Affiche() const ;
        
        
 		/*!
		* \return Retourne la taille du BigInt
		*
		*/       	
        int nb_chiffre();
        
        
 		/*!
		* \return retourne la somme de tous les chiffres du BigInt
		*
		*/    		   
        int somme_chiffre();       

};
